{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([100, 120])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.randn(dataset.fx.shape).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "\n",
    "class time_series_paper(Dataset):\n",
    "    \"\"\"synthetic time series dataset from section 5.1\"\"\"\n",
    "    \n",
    "    def __init__(self,t0=96,N=4500,transform=None):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            t0: previous t0 data points to predict from\n",
    "            N: number of data points\n",
    "            transform: any transformations to be applied to time series\n",
    "        \"\"\"\n",
    "        self.t0 = t0\n",
    "        self.N = N\n",
    "        self.transform = None\n",
    "        \n",
    "        # time points\n",
    "        self.x = torch.cat(N*[torch.arange(0,t0+24).type(torch.float).unsqueeze(0)])\n",
    "\n",
    "        # sinuisoidal signal\n",
    "        A1,A2,A3 = 60 * torch.rand(3,N)\n",
    "        A4 = torch.max(A1,A2)        \n",
    "        self.fx = torch.cat([A1.unsqueeze(1)*torch.sin(np.pi*self.x[0,0:12]/6)+72 ,\n",
    "                        A2.unsqueeze(1)*torch.sin(np.pi*self.x[0,12:24]/6)+72 ,\n",
    "                        A3.unsqueeze(1)*torch.sin(np.pi*self.x[0,24:t0]/6)+72,\n",
    "                        A4.unsqueeze(1)*torch.sin(np.pi*self.x[0,t0:t0+24]/12)+72],1)\n",
    "        \n",
    "        # add noise\n",
    "        self.fx = self.fx + torch.randn(self.fx.shape)\n",
    "        \n",
    "        self.masks = self._generate_square_subsequent_mask(24+1)\n",
    "                \n",
    "        \n",
    "        # print out shapes to confirm desired output\n",
    "        print(\"x: {}*{}\".format(*list(self.x.shape)),\n",
    "              \"fx: {}*{}\".format(*list(self.fx.shape)))        \n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.fx)\n",
    "    \n",
    "    def __getitem__(self,idx):\n",
    "        if torch.is_tensor(idx):\n",
    "            idx = idx.tolist()\n",
    "            \n",
    "        #sample = {\"x\":self.x[idx,0:self.t0],\n",
    "        #          \"x_next\":self.x[idx,self.t0:self.t0+24],\n",
    "        #          \"fx\": self.fx[idx,0:self.t0],\n",
    "        #          \"fx_next\":self.fx[idx,self.t0:self.t0+24],\n",
    "        #          \"attention_masks\":self.masks}\n",
    "        \n",
    "        sample = (self.x[idx,0:self.t0-1],\n",
    "                  self.x[idx,self.t0-1:self.t0+24],\n",
    "                  self.fx[idx,0:self.t0-1],\n",
    "                  self.fx[idx,self.t0-1:self.t0+24],\n",
    "                  self.masks)\n",
    "        \n",
    "        if self.transform:\n",
    "            sample=self.transform(sample)\n",
    "            \n",
    "        return sample\n",
    "    \n",
    "    def _generate_square_subsequent_mask(self,sz):\n",
    "        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)\n",
    "        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))\n",
    "        return mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "\n",
    "class time_series_decoder_paper(Dataset):\n",
    "    \"\"\"synthetic time series dataset from section 5.1\"\"\"\n",
    "    \n",
    "    def __init__(self,t0=96,N=4500,transform=None):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            t0: previous t0 data points to predict from\n",
    "            N: number of data points\n",
    "            transform: any transformations to be applied to time series\n",
    "        \"\"\"\n",
    "        self.t0 = t0\n",
    "        self.N = N\n",
    "        self.transform = None\n",
    "        \n",
    "        # time points\n",
    "        self.x = torch.cat(N*[torch.arange(0,t0+24).type(torch.float).unsqueeze(0)])\n",
    "\n",
    "        # sinuisoidal signal\n",
    "        A1,A2,A3 = 60 * torch.rand(3,N)\n",
    "        A4 = torch.max(A1,A2)        \n",
    "        self.fx = torch.cat([A1.unsqueeze(1)*torch.sin(np.pi*self.x[0,0:12]/6)+72 ,\n",
    "                        A2.unsqueeze(1)*torch.sin(np.pi*self.x[0,12:24]/6)+72 ,\n",
    "                        A3.unsqueeze(1)*torch.sin(np.pi*self.x[0,24:t0]/6)+72,\n",
    "                        A4.unsqueeze(1)*torch.sin(np.pi*self.x[0,t0:t0+24]/12)+72],1)\n",
    "        \n",
    "        # add noise\n",
    "        self.fx = self.fx + torch.randn(self.fx.shape)\n",
    "        \n",
    "        self.masks = self._generate_square_subsequent_mask(t0)\n",
    "                \n",
    "        \n",
    "        # print out shapes to confirm desired output\n",
    "        print(\"x: {}*{}\".format(*list(self.x.shape)),\n",
    "              \"fx: {}*{}\".format(*list(self.fx.shape)))        \n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.fx)\n",
    "    \n",
    "    def __getitem__(self,idx):\n",
    "        if torch.is_tensor(idx):\n",
    "            idx = idx.tolist()\n",
    "            \n",
    "        \n",
    "        sample = (self.x[idx,:],\n",
    "                  self.fx[idx,:],\n",
    "                  self.masks)\n",
    "        \n",
    "        if self.transform:\n",
    "            sample=self.transform(sample)\n",
    "            \n",
    "        return sample\n",
    "    \n",
    "    def _generate_square_subsequent_mask(self,t0):\n",
    "        mask = torch.zeros(t0+24,t0+24)\n",
    "        for i in range(0,t0):\n",
    "            mask[i,t0:] = 1 \n",
    "        for i in range(t0,t0+24):\n",
    "            mask[i,i+1:] = 1\n",
    "        mask = mask.float().masked_fill(mask == 1, float('-inf'))#.masked_fill(mask == 1, float(0.0))\n",
    "        return mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 100*120 fx: 100*120\n"
     ]
    }
   ],
   "source": [
    "d = time_series_decoder_paper(96,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {},
   "outputs": [],
   "source": [
    "class time_series_missing_paper(Dataset):\n",
    "    \"\"\"synthetic time series dataset from section 5.1\"\"\"\n",
    "    \n",
    "    def __init__(self,t0=96,N=4500,missing_chunk=50,transform=None):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            t0: previous t0 data points to predict from\n",
    "            N: number of data points\n",
    "            transform: any transformations to be applied to time series\n",
    "        \"\"\"\n",
    "        self.t0 = t0\n",
    "        self.N = N\n",
    "        self.transform = None\n",
    "        \n",
    "        # time points\n",
    "        self.x = torch.cat(N*[torch.arange(0,t0+24).type(torch.float).unsqueeze(0)])\n",
    "\n",
    "        # sinuisoidal signal\n",
    "        A1,A2,A3 = 60 * torch.rand(3,N)\n",
    "        A4 = torch.max(A1,A2)        \n",
    "        self.fx = torch.cat([A1.unsqueeze(1)*torch.sin(np.pi*self.x[0,0:12]/6)+72 ,\n",
    "                        A2.unsqueeze(1)*torch.sin(np.pi*self.x[0,12:24]/6)+72 ,\n",
    "                        A3.unsqueeze(1)*torch.sin(np.pi*self.x[0,24:t0]/6)+72,\n",
    "                        A4.unsqueeze(1)*torch.sin(np.pi*self.x[0,t0:t0+24]/12)+72],1)\n",
    "        \n",
    "        # add noise\n",
    "        self.fx = self.fx + torch.randn(self.fx.shape)\n",
    "        \n",
    "\n",
    "        src_mask = torch.zeros(t0-1,t0-1)\n",
    "        \n",
    "        self.fx_missing = torch.zeros((N,t0+24-missing_chunk)) \n",
    "        self.x_missing = torch.zeros((N,t0+24-missing_chunk)) \n",
    "        \n",
    "        self.x_prior = torch.zeros((N,t0-1-missing_chunk))\n",
    "        self.x_post = torch.zeros((N,1+24))\n",
    "        self.fx_prior = torch.zeros((N,t0-1-missing_chunk))\n",
    "        self.fx_post = torch.zeros((N,1+24))\n",
    "        \n",
    "        for j in range(0,self.fx.shape[0]):\n",
    "            missing_idx = torch.randint(24,t0-1-missing_chunk,(1,)).item()\n",
    "            desired_idx = torch.LongTensor([i for i in np.arange(0,t0+24) if i not in np.arange(missing_idx,missing_idx+missing_chunk)])\n",
    "            \n",
    "            \n",
    "            self.fx_missing[j,:] = self.fx[j,desired_idx]\n",
    "            self.x_missing[j,:] = self.x[j,desired_idx]\n",
    "                        \n",
    "            idx1 = desired_idx[desired_idx < (t0-1)].squeeze()\n",
    "            idx2 = desired_idx[desired_idx >= (t0-1)].squeeze()\n",
    "\n",
    "            self.x_prior[j,:] = self.x[j,idx1]\n",
    "            self.x_post[j,:] = self.x[j,idx2]\n",
    "            self.fx_prior[j,:] = self.fx[j,idx1]\n",
    "            self.fx_post[j,:] = self.fx[j,idx2]\n",
    "        \n",
    "            \n",
    "        self.masks = self._generate_square_subsequent_mask(24+1)\n",
    "        \n",
    "                \n",
    "        \n",
    "        # print out shapes to confirm desired output\n",
    "        print(\"x: {}*{}\".format(*list(self.x.shape)),\n",
    "              \"fx: {}*{}\".format(*list(self.fx.shape)))        \n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.fx)\n",
    "    \n",
    "    def __getitem__(self,idx):\n",
    "        if torch.is_tensor(idx):\n",
    "            idx = idx.tolist()\n",
    "            \n",
    "        #sample = {\"x\":self.x[idx,0:self.t0],\n",
    "        #          \"x_next\":self.x[idx,self.t0:self.t0+24],\n",
    "        #          \"fx\": self.fx[idx,0:self.t0],\n",
    "        #          \"fx_next\":self.fx[idx,self.t0:self.t0+24],\n",
    "        #          \"attention_masks\":self.masks}\n",
    "        \n",
    "        sample = (self.x_prior[idx],\n",
    "                  self.x_post[idx],\n",
    "                  self.fx_prior[idx],\n",
    "                  self.fx_post[idx],\n",
    "                  self.masks)\n",
    "        \n",
    "        if self.transform:\n",
    "            sample=self.transform(sample)\n",
    "            \n",
    "        return sample\n",
    "    \n",
    "    def _generate_square_subsequent_mask(self,sz):\n",
    "        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)\n",
    "        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))\n",
    "        return mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [],
   "source": [
    "t0 = 96\n",
    "N = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Missing Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 4500*120 fx: 4500*120\n"
     ]
    }
   ],
   "source": [
    "dataset_missing = time_series_missing_paper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = torch.randint(0,N,(1,)).item()\n",
    "plt.plot(dataset_missing.x_missing[idx].numpy(),dataset_missing.fx_missing[idx].numpy(),'r*--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regular dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 70.5897,  71.3960,  74.2224,  72.7838,  73.0146,  73.4754,  71.6909,\n",
       "         71.5867,  69.3949,  69.7779,  69.7159,  71.5530,  72.4754,  84.1934,\n",
       "         94.2802,  97.8591,  94.3799,  88.1868,  71.4238,  58.6138,  49.9049,\n",
       "         46.5077,  48.8446,  59.6799,  71.7918,  97.0033, 114.5875, 121.6640,\n",
       "        115.5731,  96.6806,  71.4558,  47.1842,  26.2378,  22.8943,  28.7757,\n",
       "         46.8186,  72.5706,  97.6164, 115.9201, 122.0926, 117.1975,  96.7661,\n",
       "         72.4509,  48.7585,  29.9226,  22.0713,  28.6758,  45.4245,  70.9435,\n",
       "         96.5456, 113.8798, 122.3693, 115.9229,  96.7538,  70.6459,  45.6632,\n",
       "         29.7052,  24.0197,  26.9687,  45.9147,  72.1766,  95.9173, 114.9766,\n",
       "        119.2269, 114.9331,  98.0689,  72.2302,  48.4391,   0.0000,   0.0000,\n",
       "          0.0000,   0.0000,   0.0000,   0.0000,   0.0000,   0.0000,   0.0000,\n",
       "          0.0000,   0.0000,   0.0000,   0.0000,   0.0000,   0.0000,   0.0000,\n",
       "          0.0000,   0.0000,   0.0000,   0.0000,   0.0000,   0.0000,   0.0000,\n",
       "          0.0000,   0.0000,  22.9594,  27.6846,  48.8818,  70.4421,  78.9068,\n",
       "         86.8354,  89.6900,  94.2432,  96.3758,  98.8524,  96.1296,  93.6107,\n",
       "         90.6223,  85.0928,  78.5435,  73.2738,  63.9520,  57.0357,  55.6567,\n",
       "         47.5267,  48.5928,  45.1724,  46.0955,  49.6469,  52.0586,  59.5391,\n",
       "         65.7712])"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset_missing.fx[99]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 100*120 fx: 100*120\n"
     ]
    }
   ],
   "source": [
    "dataset = time_series_paper(t0,N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 72.0000,  98.3769, 117.6861,  ...,  34.6975,  45.6231,  58.3464],\n",
       "        [ 72.0000,  82.8903,  90.8626,  ...,  36.7838,  47.0984,  59.1101],\n",
       "        [ 72.0000,  81.8153,  89.0006,  ...,  33.1989,  44.5635,  57.7979],\n",
       "        ...,\n",
       "        [ 72.0000,  73.8335,  75.1756,  ...,  45.5544,  53.3001,  62.3203],\n",
       "        [ 72.0000,  86.0004,  96.2494,  ...,  45.4442,  53.2222,  62.2799],\n",
       "        [ 72.0000,  84.5199,  93.6852,  ...,  54.2942,  59.4801,  65.5192]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.fx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[  0.,   1.,   2.,  ..., 117., 118., 119.],\n",
       "        [  0.,   1.,   2.,  ..., 117., 118., 119.],\n",
       "        [  0.,   1.,   2.,  ..., 117., 118., 119.],\n",
       "        ...,\n",
       "        [  0.,   1.,   2.,  ..., 117., 118., 119.],\n",
       "        [  0.,   1.,   2.,  ..., 117., 118., 119.],\n",
       "        [  0.,   1.,   2.,  ..., 117., 118., 119.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x': tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13.,\n",
       "         14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.,\n",
       "         28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41.,\n",
       "         42., 43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55.,\n",
       "         56., 57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,\n",
       "         70., 71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83.,\n",
       "         84., 85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95.]),\n",
       " 'x_next': tensor([ 96.,  97.,  98.,  99., 100., 101., 102., 103., 104., 105., 106., 107.,\n",
       "         108., 109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119.]),\n",
       " 'fx': tensor([ 72.0000,  98.3769, 117.6861, 124.7538, 117.6861,  98.3769,  72.0000,\n",
       "          45.6231,  26.3139,  19.2462,  26.3139,  45.6231,  72.0000,  78.8723,\n",
       "          83.9031,  85.7445,  83.9031,  78.8723,  72.0000,  65.1277,  60.0969,\n",
       "          58.2555,  60.0969,  65.1277,  72.0000,  75.3169,  77.7450,  78.6338,\n",
       "          77.7450,  75.3169,  72.0000,  68.6831,  66.2550,  65.3662,  66.2550,\n",
       "          68.6831,  72.0000,  75.3169,  77.7450,  78.6338,  77.7450,  75.3169,\n",
       "          72.0000,  68.6831,  66.2550,  65.3662,  66.2550,  68.6831,  72.0000,\n",
       "          75.3169,  77.7450,  78.6338,  77.7450,  75.3169,  72.0000,  68.6831,\n",
       "          66.2550,  65.3662,  66.2550,  68.6831,  72.0000,  75.3169,  77.7450,\n",
       "          78.6338,  77.7450,  75.3169,  72.0000,  68.6831,  66.2550,  65.3662,\n",
       "          66.2550,  68.6831,  72.0000,  75.3169,  77.7450,  78.6338,  77.7450,\n",
       "          75.3169,  72.0000,  68.6831,  66.2550,  65.3662,  66.2550,  68.6831,\n",
       "          72.0000,  75.3169,  77.7450,  78.6338,  77.7450,  75.3169,  72.0000,\n",
       "          68.6831,  66.2550,  65.3662,  66.2550,  68.6831]),\n",
       " 'fx_next': tensor([ 72.0000,  85.6537,  98.3770, 109.3025, 117.6861, 122.9563, 124.7538,\n",
       "         122.9562, 117.6861, 109.3025,  98.3769,  85.6537,  71.9999,  58.3463,\n",
       "          45.6231,  34.6974,  26.3138,  21.0438,  19.2462,  21.0438,  26.3139,\n",
       "          34.6975,  45.6231,  58.3464]),\n",
       " 'attention_masks': tensor([[-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf]])}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded_dict =  dataset[0:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x:  torch.Size([1, 96])\n",
      "x_next:  torch.Size([1, 24])\n",
      "fx:  torch.Size([1, 96])\n",
      "fx_next:  torch.Size([1, 24])\n",
      "attention_masks:  torch.Size([24, 24])\n"
     ]
    }
   ],
   "source": [
    "for key,value in encoded_dict.items():\n",
    "    print(\"{}: \".format(key),value.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(dataset.x[1].numpy(),dataset.fx[1].numpy())\n",
    "plt.plot(dataset.x[2].numpy(),dataset.fx[2].numpy())\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
